home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / mm / mm-0.90 / debug.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-18  |  4.6 KB  |  259 lines
  1. /*
  2.  * Copyright (c) 1986, 1990 by The Trustees of Columbia University in
  3.  * the City of New York.  Permission is granted to any individual or
  4.  * institution to use, copy, or redistribute this software so long as it
  5.  * is not sold for profit, provided this copyright notice is retained.
  6.  */
  7.  
  8. #ifndef lint
  9. static char *rcsid = "$Header: /f/src2/encore.bin/cucca/mm/tarring-it-up/RCS/debug.c,v 2.4 90/10/04 18:23:55 melissa Exp $";
  10. #endif
  11.  
  12. #include <stdio.h>
  13.  
  14. /*
  15.  * memdebug:
  16.  * variable to control memory debugging.  It must be declared in the user 
  17.  * program.
  18.  * if memdebug == 1, then action is always taken.
  19.  * if memdebug == 0, then no action is taken.
  20.  * if memdebug == -1, then the user is asked.
  21.  */
  22. extern int memdebug;
  23.  
  24.  
  25. #ifdef MDEBUG
  26.  
  27. char *malloc(), *realloc();
  28. char *set_range_check(), *check_range();
  29.  
  30. #define min(x,y) ((x) < (y) ? (x) : (y))
  31. #define RANGE     "ABCDEFGHIJKLMNOP"
  32. #define INTSIZE  sizeof(int)
  33. #define LONGSIZE sizeof(long)
  34. #define RSIZE    sizeof(RANGE)
  35. #define RFRONT   min((RSIZE/2),LONGSIZE)
  36. #define RBACK    min((RSIZE-RFRONT),LONGSIZE)
  37.  
  38. char *
  39. dmalloc(size)
  40. int size;
  41. {
  42.     char *cp;
  43.  
  44.     cp = malloc(size + RSIZE + INTSIZE);
  45.     if (cp) {
  46.     cp = set_range_check(cp, size);
  47.     m_insert(cp);
  48.     }
  49.     return(cp);
  50. }
  51.  
  52. char *
  53. dcalloc(nelem, elsize)
  54. int nelem, elsize;
  55. {
  56.     char *cp;
  57.  
  58.     cp = dmalloc(nelem * elsize);
  59.     if (cp)
  60.     bzero(cp, nelem * elsize);
  61.     return(cp);
  62. }
  63.  
  64. char *
  65. drealloc(bp,size)
  66. char *bp;
  67. int size;
  68. {
  69.     char *cp;
  70.  
  71.     if (bp == NULL) {
  72.     maybe_abort("Freeing NULL pointer");
  73.     }
  74.     else {
  75.     m_delete(bp);
  76.     cp = check_range(bp);
  77.     }
  78.     cp = realloc(cp, size + RSIZE + INTSIZE);
  79.     if (cp) {
  80.     cp = set_range_check(cp, size);
  81.     m_insert(cp);
  82.     }
  83.     return(cp);
  84. }
  85.  
  86. dfree(cp)
  87. char *cp;
  88. {
  89.     if (cp == NULL)
  90.     maybe_abort("Freeing NULL pointer");
  91.     else {
  92.     m_delete(cp);
  93.     cp = check_range(cp);
  94.     }
  95.     return(free(cp));
  96. }
  97.  
  98. char *
  99. set_range_check(cp,size)
  100. char *cp;
  101. int size;
  102. {
  103.     register int i;
  104.     int tmp = size;
  105.  
  106.     for(i = 0; i < INTSIZE; i++) {    /* set the size in the string */
  107.     cp[i] = tmp & 0xff;
  108.     tmp >>= 8;
  109.     }
  110.     cp += INTSIZE;            /* skip the size */
  111.  
  112.     for(i = 0; i < RFRONT; i++)        /* set the front of the range check */
  113.     cp[i] = RANGE[i];        /* string */
  114.  
  115.     cp += RFRONT;            /* skip the front range check */
  116.  
  117.     for(i = 0; i < RBACK; i++)        /* set the back odf the range check */
  118.     cp[i+size] = RANGE[i+RFRONT];
  119.  
  120.     return(cp);
  121. }
  122.  
  123. char *
  124. check_range(cp)
  125. char *cp;
  126. {
  127.     register char *bp = cp - RFRONT - INTSIZE;
  128.     char *xp = bp;
  129.     register int i;
  130.     int size = 0;
  131.  
  132.     for(i = 0 ; i < INTSIZE; i++) {    /* get the size out of the string */
  133.     size <<= 8;
  134.     size |= bp[INTSIZE-i-1] & 0xff;
  135.     }
  136.     bp += INTSIZE;
  137.  
  138.     for(i = 0; i < RFRONT; i++)        /* check front range check */
  139.     if (bp[i] != RANGE[i]) {
  140.         maybe_abort("leftside malloc buffer overrun");
  141.         break;
  142.     }
  143.     bp += RFRONT;            /* skip front range check */
  144.  
  145.     for(i = 0; i < RBACK; i++)        /* check back rnage check */
  146.     if (bp[i+size] != RANGE[i+RFRONT]) {
  147.         maybe_abort("rightside malloc buffer overrun");
  148.         break;
  149.     }
  150.     return(xp);
  151. }
  152.  
  153.  
  154. #define BUCKETS 10000
  155. char *m_used[BUCKETS];
  156.  
  157. m_insert(cp)
  158. register char *cp;
  159. {
  160.     register int i;
  161.  
  162.     for(i = 0; i < BUCKETS; i++)
  163.     if (m_used[i] == 0) {
  164.         m_used[i] = cp;
  165.         return;
  166.     }
  167. }
  168.  
  169. m_delete(cp)
  170. register char *cp;
  171. {
  172.     register int i;
  173.  
  174.     for(i = 0; i < BUCKETS; i++)
  175.     if (m_used[i] == cp) {
  176.         m_used[i] = 0;
  177.         return;
  178.     }
  179.     maybe_abort("Freeing unmalloc'ed pointer");
  180. }
  181.  
  182. m_init() {
  183.     register int i;
  184.     for(i = 0; i < BUCKETS; i++)
  185.     m_used[i] = 0;
  186. }
  187.  
  188. m_done() {
  189.     register int i,j;
  190.  
  191. #ifdef undef
  192.     for(i = 0; i < BUCKETS; i++)
  193.     if (m_used[i] != 0) {
  194.         if (memdebug) {
  195.         if (j == 0)
  196.             fprintf(stderr,"unfree'ed buffers, indices: ");
  197.         fprintf(stderr,"%d, ", i);
  198.         j++;
  199.         }
  200.     }
  201.     if (j)
  202.     fprintf(stderr,"\n");
  203.     if (j)
  204.     maybe_abort("Unfree'ed malloc buffers");
  205. #endif
  206. }
  207.  
  208. m_checkranges() {
  209.     int i;
  210.  
  211.     for ( i = 0; i < BUCKETS; i++)
  212.     if (m_used[i])
  213.         check_range(m_used[i]);
  214. }
  215.  
  216. #endif /* MDEBUG */
  217.  
  218. maybe_abort(str)
  219. char *str;
  220. {
  221.     if (memdebug == 0)
  222.     return;
  223.     fprintf(stderr,"%s\n",str);
  224.     if (memdebug == 1)
  225.     abort();
  226.     if (memdebug == -1)
  227.     if (ask("Abort? "))
  228.         abort();
  229. }
  230.  
  231. ask(str)
  232. char *str;
  233. {
  234.     char buf[100];
  235.     FILE *in;
  236.     int fd;
  237.     
  238.     fd = dup(fileno(stdin));
  239.     in = fdopen(fd, "r");
  240.     while(1) {
  241.     fprintf(stderr,str);
  242.     fflush(stderr);
  243.     if (fgets(buf, 99, in) == NULL)    /* EOF? */
  244.         return(0);
  245.     if (buf[0] == 'n' || buf[0] == 'N') {
  246.         fclose(in);
  247.         return(0);
  248.     }
  249.     if (buf[0] == 'y' || buf[0] == 'Y') {
  250.         fclose(in);
  251.         return(1);
  252.     }
  253.     fprintf(stderr,"please answer y/n.\n");
  254.     }
  255. }
  256.  
  257.  
  258.  
  259.